package lemon.mvc.spring;

///*
//*  Copyright Beijing 58 Information Technology Co.,Ltd.
//*
//*  Licensed to the Apache Software Foundation (ASF) under one
//*  or more contributor license agreements.  See the NOTICE file
//*  distributed with this work for additional information
//*  regarding copyright ownership.  The ASF licenses this file
//*  to you under the Apache License, Version 2.0 (the
//*  "License"); you may not use this file except in compliance
//*  with the License.  You may obtain a copy of the License at
//*
//*        http://www.apache.org/licenses/LICENSE-2.0
//*
//*  Unless required by applicable law or agreed to in writing,
//*  software distributed under the License is distributed on an
//*  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//*  KIND, either express or implied.  See the License for the
//*  specific language governing permissions and limitations
//*  under the License.
//*/
//package com.bj58.wf.mvc.thirdparty;
//
//import java.util.ArrayList;
//import java.util.Collection;
//import java.util.List;
//import java.util.StringTokenizer;
//
///**
// * @author lemon
// */
//public class StringUtil {
//
//    /**
//     * Tokenize the given String into a String array via a StringTokenizer.
//     * Trims tokens and omits empty tokens.
//     * <p>The given delimiters string is supposed to consist of any number of
//     * delimiter characters. Each of those characters can be used to separate
//     * tokens. A delimiter is always a single character; for multi-character
//     * delimiters, consider using <code>delimitedListToStringArray</code>
//     * @param str the String to tokenize
//     * @param delimiters the delimiter characters, assembled as String
//     * (each of those characters is individually considered as delimiter).
//     * @return an array of the tokens
//     * @see java.util.StringTokenizer
//     * @see String#trim()
//     */
//    public static String[] tokenizeToStringArray(String str, String delimiters) {
//        return tokenizeToStringArray(str, delimiters, true, true);
//    }
//
//    /**
//     * Tokenize the given String into a String array via a StringTokenizer.
//     * <p>The given delimiters string is supposed to consist of any number of
//     * delimiter characters. Each of those characters can be used to separate
//     * tokens. A delimiter is always a single character; for multi-character
//     * delimiters, consider using <code>delimitedListToStringArray</code>
//     * @param str the String to tokenize
//     * @param delimiters the delimiter characters, assembled as String
//     * (each of those characters is individually considered as delimiter)
//     * @param trimTokens trim the tokens via String's <code>trim</code>
//     * @param ignoreEmptyTokens omit empty tokens from the result array
//     * (only applies to tokens that are empty after trimming; StringTokenizer
//     * will not consider subsequent delimiters as token in the first place).
//     * @return an array of the tokens (<code>null</code> if the input String
//     * was <code>null</code>)
//     * @see java.util.StringTokenizer
//     * @see String#trim()
//     */
//    public static String[] tokenizeToStringArray(
//            String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
//
//        if (str == null) {
//            return null;
//        }
//        StringTokenizer st = new StringTokenizer(str, delimiters);
//        List<String> tokens = new ArrayList<String>();
//        while (st.hasMoreTokens()) {
//            String token = st.nextToken();
//            if (trimTokens) {
//                token = token.trim();
//            }
//            if (!ignoreEmptyTokens || token.length() > 0) {
//                tokens.add(token);
//            }
//        }
//        return toStringArray(tokens);
//    }
//    /**
//     * Copy the given Collection into a String array.
//     * The Collection must contain String elements only.
//     * @param collection the Collection to copy
//     * @return the String array (<code>null</code> if the passed-in
//     * Collection was <code>null</code>)
//     */
//    public static String[] toStringArray(Collection<String> collection) {
//        if (collection == null) {
//            return null;
//        }
//        return collection.toArray(new String[collection.size()]);
//    }
//
//
//    /**
//     * Check whether the given String has actual text.
//     * More specifically, returns <code>true</code> if the string not <code>null</code>,
//     * its length is greater than 0, and it contains at least one non-whitespace character.
//     * @param str the String to check (may be <code>null</code>)
//     * @return <code>true</code> if the String is not <code>null</code>, its length is
//     * greater than 0, and it does not contain whitespace only
//     * @see #hasText(CharSequence)
//     */
//    public static boolean hasText(String str) {
//        return hasText((CharSequence) str);
//    }
//
//
//    public static boolean hasText(CharSequence str) {
//        if (!hasLength(str)) {
//            return false;
//        }
//        int strLen = str.length();
//        for (int i = 0; i < strLen; i++) {
//            if (!Character.isWhitespace(str.charAt(i))) {
//                return true;
//            }
//        }
//        return false;
//    }
//
//    /**
//     * 检查包含空白字符在内的字符系列长度
//     * <p><pre>
//     * StringUtils.hasLength(null) = false
//     * StringUtils.hasLength("") = false
//     * StringUtils.hasLength(" ") = true
//     * StringUtils.hasLength("Hello") = true
//     * </pre>
//     * @param str the CharSequence to check (may be <code>null</code>)
//     * @return <code>true</code> if the CharSequence is not null and has length
//     * @see #hasText(String)
//     */
//    public static boolean hasLength(CharSequence str) {
//        return (str != null && str.length() > 0);
//    }
//
//
//    /**
//     * Count the occurrences of the substring in string s.
//     * @param str string to search in. Return 0 if this is null.
//     * @param sub string to search for. Return 0 if this is null.
//     */
//    public static int countOccurrencesOf(String str, String sub) {
//        if (str == null || sub == null || str.length() == 0 || sub.length() == 0) {
//            return 0;
//        }
//        int count = 0;
//        int pos = 0;
//        int idx;
//        while ((idx = str.indexOf(sub, pos)) != -1) {
//            ++count;
//            pos = idx + sub.length();
//        }
//        return count;
//    }
//    public static String composeMessage(String source, String... replacement) {
//		if (replacement.length == 0) {
//			return source;
//		}
//		for (int i = 0; i < replacement.length; i++) {
//			int start = source.indexOf("{");
//			if (start < 0) {
//				return source;
//			}
//			int end = source.indexOf("}") + 1;
//			String pattern = source.substring(start, end);
//			if(replacement[i]==null){
//				source = source.replace(pattern, "");
//			}else{
//				source = source.replace(pattern, replacement[i]);
//			}
//		}
//		return source;
//	}
//}
